package com.ly.mpayment.core.util;

import java.text.DateFormat;
import java.text.ParseException;
import java.text.ParsePosition;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Calendar;
import java.util.Date;
import java.util.GregorianCalendar;
import java.util.List;

import org.apache.commons.lang.StringUtils;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.apache.log4j.Logger;


/**
 * DateUtils.java <br/>
 * 所属类别:时间公共方法 <br/>
 * 用途: 通过此工具类减少获取时间相关代码量提高提高代码重用<br/>
 * Date:2013-6-13<br/>
 * Time:下午2:31:24 <br/>
 * Version:1.0 <br/>
 */
public class DateUtils extends Date {

	static Logger logger = Logger.getLogger(DateUtils.class);
	/** yyyy-MM-dd HH:mm:ss */
	public static String pattern = "yyyy-MM-dd HH:mm:ss";

	/**
	 * 默认日期格式
	 */
	public static String DEFAULT_FORMAT = "yyyy-MM-dd";

	public static String yearMonth = "yyyyMM";

	public static String year = "yyyy";

	/**
	 * <p>
	 * 将时间格式化为pattern格式字符串
	 * </P>
	 *
	 *
	 * @Date 2013-6-13 下午2:40:15
	 * @param time
	 *            需格式化时间
	 * @param pattern
	 *            返回字符串格式
	 * @return 返回格式为pattern的格式字符串,如pattern为NULL或""则 返回默认为"yyyy-MM-dd HH:mm:ss"
	 *         格式字符串
	 */
	public static String convert(long time, String pattern) {

		if (StringUtils.isEmpty(pattern)) {
			pattern = "yyyy-MM-dd HH:mm:ss";
		}
		SimpleDateFormat format = new SimpleDateFormat(pattern);
		return format.format(time);
	}

  /**
   * 获取时区时间
   * @return
   */
    public static String getTimeZone() {
      pattern = "yyyy-MM-dd'T'HH:mm:ssXXX";
      SimpleDateFormat format = new SimpleDateFormat(pattern);
      return format.format(new Date());
    }



	/**
	 * <p>
	 * 将时间格式化为pattern格式字符串
	 * </P>
	 *
	 *
	 * @Date 2013-6-13 下午2:40:15
	 * @param time
	 *            需格式化时间
	 * @param pattern
	 *            返回字符串格式
	 * @return 返回格式为pattern的格式字符串,如pattern为NULL或""则 返回默认为"yyyy-MM-dd HH:mm:ss"
	 *         格式字符串
	 */
	public static String convert(Date time, String pattern) {
		return convert(time.getTime(), pattern);
	}

	/**
	 * <p>
	 * 格式化时间
	 * </P>
	 *
	 *
	 * @Date 2013-6-13 下午2:33:41
	 * @param time
	 *            需格式化时间
	 * @return 返回默认为"yyyy-MM-dd HH:mm:ss" 格式字符串
	 */
	public static String convert(long time) {
		return convert(time, null);
	}

	/**
	 * <p>
	 * 格式化时间
	 * </P>
	 *
	 *
	 * @Date 2013-6-13 下午2:33:41
	 * @param time
	 *            需格式化时间
	 * @return 返回默认为"yyyy-MM-dd HH:mm:ss" 格式字符串
	 */
	public static String convert(Date time) {
		return convert(time.getTime(), null);
	}

	/**
	 * <p>
	 * 格式化时间
	 * </P>
	 * 默认为"yyyy-MM-dd HH:mm:ss" 格式字符串
	 *
	 *
	 * @Date 2013-6-13 下午2:33:41
	 * @param time
	 *            需格式化时间
	 * @return 返回 Date
	 */
	public static Date convert(String time) {
		try {
			if (StringUtils.isEmpty(pattern)) {
				pattern = DEFAULT_FORMAT;
			}
			SimpleDateFormat format = new SimpleDateFormat(pattern);
			return format.parse(time);
		} catch (ParseException e) {
			 System.out.println(e.getMessage());
			return null;
		}
	}

	public static Date convert(String time, String formatStr) {
		try {
			if (StringUtils.isEmpty(formatStr)) {
				pattern = DEFAULT_FORMAT;
			}
			SimpleDateFormat format = new SimpleDateFormat(formatStr);
			return format.parse(time);
		} catch (ParseException e) {
			// System.out.println(e.getMessage());
			return null;
		}
	}

	/**
	 * 转换格式 外部可以使用
	 */
	public static final String FORMAT_PATTERN_STRING = DEFAULT_FORMAT;
	public static final String full_FORMAT_PATTERN_STRING = "yyyy-MM-dd HH:mm:ss";
	private static final Log log = LogFactory.getLog(DateUtils.class);

	private static SimpleDateFormat format = new SimpleDateFormat(FORMAT_PATTERN_STRING);

	/**
	 * 得到始日期到结束日期之间的间隔日期
	 *
	 * @param g1
	 * @param g2
	 * @return 间隔日期集合， 没有间隔日期，返回空list对象
	 */
	@SuppressWarnings("rawtypes")
	private static List countDateFromStartToEnd(GregorianCalendar g1, GregorianCalendar g2) {
		ArrayList<Date> list = new ArrayList<Date>();
		GregorianCalendar gc1, gc2;

		if (g2.after(g1)) {
			gc2 = (GregorianCalendar) g2.clone();
			gc1 = (GregorianCalendar) g1.clone();
		} else {
			gc2 = (GregorianCalendar) g1.clone();
			gc1 = (GregorianCalendar) g2.clone();
		}
		// list.add(gc1.getTime());//不包含已经有纪录的日期
		while (gc1.before(gc2)) {
			gc1.add(Calendar.DATE, 1);

			int intday1 = gc1.get(Calendar.DAY_OF_MONTH);
			int intday2 = gc2.get(Calendar.DAY_OF_MONTH);
			if (intday1 == intday2)// 不包含当天日期
				list.add(gc1.getTime());
		}
		return list;
	}

	/**
	 * 按照默认格式化串形式得到日期间间隔
	 *
	 * @param start
	 * @param end
	 * @return
	 */
	@SuppressWarnings("rawtypes")
	public static List getDateFromStartToEnd(Date start, Date end) {

		String dateStr = format.format(start);
		String dateEnd = format.format(end);

		Date strdate = null;
		Date endate = null;
		try {
			strdate = format.parse(dateStr);
			endate = format.parse(dateEnd);
			GregorianCalendar gc1 = new GregorianCalendar();
			GregorianCalendar gc2 = new GregorianCalendar();
			gc1.setTime(strdate);
			gc2.setTime(endate);
			return countDateFromStartToEnd(gc1, gc2);
		} catch (ParseException e) {
			e.printStackTrace();
		}
		return null;
	}

	/**
	 * 没有格式化的日期统计方式 暂时没有使用
	 *
	 * @param start
	 * @param end
	 * @return
	 */
	@SuppressWarnings("rawtypes")
	public static List getDateFromStartToEndNoFormat(Date start, Date end) {
		GregorianCalendar gc1 = new GregorianCalendar();
		GregorianCalendar gc2 = new GregorianCalendar();
		gc1.setTime(start);
		gc2.setTime(end);
		return countDateFromStartToEnd(gc1, gc2);
	}

	/**
	 * 转换日期成字符串
	 *
	 * @param date
	 * @param formatPattern
	 *            希望把日期格式成的样式，如果为空，采用yyyy-mm-dd
	 * @return
	 */
	public static String convertDateToString(Date date, String formatPattern) {
		if (StringUtils.isNotBlank(formatPattern)) {
			SimpleDateFormat _format = new SimpleDateFormat(formatPattern);
			return _format.format(date);
		}
		return format.format(date);
	}

	public static String convertYearMonth(Date date, String formatPattern) {
		if (StringUtils.isNotBlank(formatPattern)) {
			SimpleDateFormat _format = new SimpleDateFormat(formatPattern);
			return _format.format(date);
		}
		return format.format(date);
	}

	/**
	 * 转化字符串成日期对象
	 *
	 * @param dateString
	 *            如2007-10-20
	 * @return
	 */
	public static Date convertStringToDate(String dateString) {
		try {
			if (StringUtils.isNotBlank(dateString)) {
				return format.parse(dateString);
			}
		} catch (ParseException e) {
			// e.printStackTrace();
			log.error(e.getMessage(), e);
		}
		return null;
	}

	/**
	 * 按照指定格式格式化日期
	 *
	 * @param dateString
	 * @param formatPattern
	 *            希望把日期格式成的样式，如果为空，采用yyyy-mm-dd
	 * @return
	 */
	public static Date convertStringToDate(String dateString, String formatPattern) {

		if (StringUtils.isNotBlank(formatPattern)) {
			SimpleDateFormat _format = new SimpleDateFormat(formatPattern);
			try {
				return _format.parse(dateString);
			} catch (ParseException e) {
				// e.printStackTrace();
				log.error(e.getMessage(), e);
			}
		}
		return convertStringToDate(dateString);
	}

	/**
	 * 得到制定日期的月份的起始日期 如输入2008-09-20,返回2008-09-01,2008-09-30
	 *
	 * @param dateString
	 *            只支持两种,字符串或者日期格式
	 * @return 2008-10-16-liuyang
	 */
	public static Object[] getStartAndEndDateOfMonth(Object dateString) {
		Date thedate = null;
		if (dateString instanceof String)
			thedate = convertStringToDate(dateString.toString());
		else if (dateString instanceof Date)
			thedate = (Date) dateString;
		else
			return null;
		GregorianCalendar gc = new GregorianCalendar();
		gc.setTime(thedate);
		int start = gc.getActualMinimum(Calendar.DAY_OF_MONTH);
		int end = gc.getActualMaximum(Calendar.DAY_OF_MONTH);
		String startstr = gc.get(Calendar.YEAR) + "-" + (gc.get(Calendar.MONTH) + 1) + "-" + start;
		String endstr = gc.get(Calendar.YEAR) + "-" + (gc.get(Calendar.MONTH) + 1) + "-" + end;
		return new Object[] { convertStringToDate(startstr), convertStringToDate(endstr) };
	}

	public static final String YYYY_MM_DD = "yyyy-MM-dd HH:mm:ss";

	/**
	 * 日期格式化对象.
	 */
	private static SimpleDateFormat df = new SimpleDateFormat();

	// /**
	// * 日期对象转成字符串
	// *
	// * @param value
	// * @param format
	// * @return
	// */
	// public static String convert(Date value, String format) {
	// String strDate = "";
	// if (value == null) {
	// return null;
	// } else if ((value instanceof Date) && format != null
	// && !format.equals("")) {
	// df.applyPattern(format);
	// strDate = df.format(value);
	// }
	// return strDate;
	// }

	/**
	 * 字符串对象转成时间
	 *
	 * @param value
	 * @param format
	 * @return
	 */
	public static Date parse(String value, String format) {
		Date date = null;
		if (value == null) {
			return null;
		} else if ((value instanceof String) && format != null && !format.equals("")) {
			df.applyPattern(format);
			try {
				date = df.parse(value);
			} catch (ParseException e) {
				logger.info(e);
			}
		}
		return date;
	}

	/**
	 * 字符串对象转成时间
	 *
	 * @param value
	 * @param format
	 * @return
	 */
	public static Date parseFormat(String value, String format) {
		return new SimpleDateFormat(format).parse(value, new ParsePosition(0));
	}


	/**
	 * 当月第一天
	 * @return
	 */
	public static String getCurrMonthDay() {
		Calendar cal = Calendar.getInstance();
		cal.setTime(new Date());
		cal.set(Calendar.DAY_OF_MONTH, 1);
		return new SimpleDateFormat("yyyy-MM-dd").format(cal.getTime());
	}


	//指定日期月份减去一后的 最大天数

	/**
	 * 上月的第一天
	 * @return
	 */
	public static String getCurrUpMonthDay() {
		Calendar cal = Calendar.getInstance();
		cal.setTime(new Date());
		cal.add(Calendar.MONTH, -1);
		cal.set(Calendar.DAY_OF_MONTH, 1);
		return new SimpleDateFormat("yyyy-MM-dd").format(cal.getTime());
	}
	public static String getCurrUpLastMonthDay() {
		Calendar cal = Calendar.getInstance();
		cal.setTime(new Date());
		cal.add(Calendar.MONTH, -1);
		cal.set(Calendar.DAY_OF_MONTH, 1);
		cal.set(Calendar.DATE, cal.getActualMaximum(Calendar.DATE));
		return new SimpleDateFormat("yyyy-MM-dd").format(cal.getTime());
	}

	/**
	 * 返回当前时间
	 *
	 * @Title getNowDate
	 * @Description TODO
	 * @return
	 */
	public static Date getNowDate() {
		return new Date();
	}

	/**
	 * 返回当前时间 yyyy-MM-dd HH:mm:ss
	 *
	 * @Title getNowDate
	 * @Description TODO
	 * @return
	 */
	public static String getNowDateYMDHMS() {
		return toLongDate(new Date());
	}

	/**
	 * 返回当前时间 yyyy-MM-dd HH:mm:ss
	 *
	 * @Title getNowDate
	 * @Description TODO
	 * @return
	 */
	public static String getNowDateYMD() {
		return toShortDate(new Date());
	}

	// /**
	// * 设定查询开始和结束时间
	// * @Title getcreateTime
	// * @Description TODO
	// * @param time
	// * @param parameters
	// */
	// public static void setStartTimeAndEndTime(String startTime,String
	// endTime,Map<String, Object> parameters){
	// parameters.put(":startTime",com.jl.cater.core.util.StringUtils.validate(startTime)
	// ? null : DateConverter.parse(startTime + " 00:00:00", "yyyy-MM-dd
	// HH:mm:ss"));
	// parameters.put(":endTime", StringUtils.validate(endTime) ? null :
	// DateConverter.parse(endTime + " 23:59:59","yyyy-MM-dd HH:mm:ss"));
	// }

	/**
	 * 把给定的时间加上指定的天数，可以为负
	 *
	 * @param d
	 *            日期对象
	 * @param days
	 * @return 日期对象
	 */
	public static Date addDays(Date d, int days) {
		if (d == null) {
			throw new IllegalArgumentException("参数d不能是null对象!");
		}
		Calendar calendar = Calendar.getInstance();
		calendar.setTime(d);
		calendar.add(Calendar.HOUR, days * 24);
		return calendar.getTime();
	}

	/**
	 * 把给定的时间加上指定的年份，可以为负, 返回新的被加上了年份的日期对象,不影响参数日期对象值
	 *
	 * @param d
	 * @param years
	 * @return 日期对象
	 */
	public static Date addYears(Date d, int years) {
		if (d == null) {
			throw new IllegalArgumentException("参数d不能是null对象!");
		}
		Calendar calendar = Calendar.getInstance();
		calendar.setTime(d);
		calendar.add(Calendar.YEAR, years);
		return calendar.getTime();
	}

	/**
	 * 返回指定日期的月份的天数量
	 *
	 * @param d
	 *            日期对象
	 */
	public static int getDaysOfMonth(Date d) {
		int year = getYearOfDate(d);
		int month = getMonthOfYear(d);
		return getDaysOfMonth(year, month);
	}

	public static int getYearOfDate(Date d) {
		if (d == null) {
			throw new IllegalArgumentException("参数d不能是null对象!");
		}
		Calendar calendar = Calendar.getInstance();
		calendar.setTime(d);
		return calendar.get(Calendar.YEAR);
	}

	/**
	 * 返回一个时间的月份整数
	 *
	 * @param d
	 * @return 月份
	 */
	public static int getMonthOfYear(Date d) {
		if (d == null) {
			throw new IllegalArgumentException("参数d不能是null对象!");
		}
		Calendar calendar = Calendar.getInstance();
		calendar.setTime(d);
		return calendar.get(Calendar.MONTH) + 1;
	}

	/**
	 * 返回指定日期的月份的天数量
	 *
	 * @param year
	 *            年
	 * @param month
	 *            月
	 */
	public static int getDaysOfMonth(int year, int month) {
		int days = 0;
		if (month == 2) {
			if (((year % 4 == 0) && (year % 100 != 0)) || (year % 400 == 0)) {
				days = 29;
			} else {
				days = 28;
			}
		}
		if ((month == 4) || (month == 6) || (month == 9) || (month == 11)) {
			days = 30;
		}
		if ((month == 1) || (month == 3) || (month == 5) || (month == 7) || (month == 8) || (month == 10)
				|| (month == 12)) {
			days = 31;
		}
		return days;
	}

	/**
	*
	*/
	private static final long serialVersionUID = 2155545266875552658L;

	public static final String dateFromat = "yyyy-MM-dd HH:mm:ss";

	/**
	 * 功能：转换为Calendar。
	 *
	 *
	 * @return Calendar
	 */
	public static Calendar toCalendar(Date date) {
		Calendar c = Calendar.getInstance();
		c.setTime(date);
		return c;
	}
	// public static void main(String[] args) {
	// System.out.println(addMonthToDate(DateUtils.getNowDate(), 3));
	// }

	/**
	 * 功能：判断日期是否和当前date对象在同一天。
	 *
	 * @param date
	 *            比较的日期
	 * @return boolean 如果在返回true，否则返回false。
	 */
	public static boolean isSameDay(Date date) {
		if (date == null) {
			throw new IllegalArgumentException("日期不能为null");
		}
		Calendar cal2 = Calendar.getInstance();
		cal2.setTime(date);
		return isSameDay(cal2, date);
	}

	/**
	 * 功能：判断日期是否和当前date对象在同一天。
	 *
	 * @param cal
	 *            比较的日期
	 * @return boolean 如果在返回true，否则返回false。
	 */
	public static boolean isSameDay(Calendar cal, Date date) {
		if (cal == null) {
			throw new IllegalArgumentException("日期不能为null");
		}
		// 当前date对象的时间
		Calendar cal1 = Calendar.getInstance();
		cal1.setTime(date);
		return (cal1.get(Calendar.ERA) == cal.get(Calendar.ERA) && cal1.get(Calendar.YEAR) == cal.get(Calendar.YEAR)
				&& cal1.get(Calendar.DAY_OF_YEAR) == cal.get(Calendar.DAY_OF_YEAR));
	}

	/**
	 * 功能：将当前日期的秒数进行重新设置。
	 *
	 *
	 * @param second
	 *            秒数
	 * @return 设置后的日期
	 */
	public static Date setSecondNew(int second, Date date) {
		Calendar c = Calendar.getInstance();
		c.setTime(date);
		c.set(Calendar.SECOND, second);
		return new Date(c.getTimeInMillis());
	}

	/**
	 * 功能：将当前日期的分钟进行重新设置。
	 *
	 *
	 * @param minute
	 *            分钟数
	 * @return 设置后的日期
	 */
	public static Date setMinuteNew(int minute, Date date) {
		Calendar c = Calendar.getInstance();
		c.setTime(date);
		c.set(Calendar.MINUTE, minute);
		return new Date(c.getTimeInMillis());
	}

	/**
	 * 功能：将当前日期的小时进行重新设置。
	 *
	 *
	 * @param hours
	 *            小时数 (24小时制)
	 * @return 设置后的日期
	 */
	public static Date setHourNew(int hour, Date date) {
		Calendar c = Calendar.getInstance();
		c.setTime(date);
		c.set(Calendar.HOUR_OF_DAY, hour);
		return new Date(c.getTimeInMillis());
	}

	/**
	 * 功能：将当前日期的天进行重新设置。
	 *
	 *
	 * @param days
	 *            某一天
	 * @return 设置后的日期
	 */
	public static Date setDayNew(int day, Date date) {
		Calendar c = Calendar.getInstance();
		c.setTime(date);
		c.set(Calendar.DATE, day);
		return new Date(c.getTimeInMillis());
	}

	/**
	 * 功能：将当前日期的月进行重新设置。
	 *
	 *
	 * @param months
	 *            某一月
	 * @return 设置后的日期
	 */
	public static Date setMonthNew(int month, Date date) {
		Calendar c = Calendar.getInstance();
		c.setTime(date);
		c.set(Calendar.MONTH, month - 1);
		return new Date(c.getTimeInMillis());
	}

	/**
	 * 功能：将当前日期的年进行重新设置。
	 *
	 *
	 * @param years
	 *            某一年
	 * @return 设置后的日期
	 */
	public static Date setYearNew(int year, Date date) {
		Calendar c = Calendar.getInstance();
		c.setTime(date);
		c.set(Calendar.YEAR, year);
		return new Date(c.getTimeInMillis());
	}

	/**
	 * 功能：得到当月有多少天。
	 *
	 * @return int
	 */
	public static int daysNumOfMonth(Date date) {
		Calendar cal = Calendar.getInstance();
		cal.setTime(date);
		return cal.getActualMaximum(Calendar.DATE);
	}

	/**
	 * long 转换为日期
	 */

	public static Date addMonthToDate(Date end, int month) {
		if (end != null) {
			SimpleDateFormat sdf = new SimpleDateFormat(DEFAULT_FORMAT);
			Calendar cal = Calendar.getInstance();
			cal.setTime(end);
			cal.add(Calendar.MONTH, month);
			try {
				// System.out.println(sdf.format(cal.getTime()));
				return sdf.parse(sdf.format(cal.getTime()));
			} catch (ParseException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		}
		return null;
	}

	/**
	 * 将yyyy-MM-dd HH:mm:ss字符串转换成日期(net.maxt.util.Date)<br/>
	 *
	 * @param dateStr
	 *            时间字符串
	 * @param 当前时间字符串的格式。
	 * @return net.maxt.util.Date 日期 ,转换异常时返回null。
	 */
	public static Date parseDate(String dateStr, SimpleDateFormat dataFormat) {
		try {
			java.util.Date d = dataFormat.parse(dateStr);
			return new Date(d.getTime());
		} catch (ParseException e) {
			e.printStackTrace();
			return null;
		}
	}

	/**
	 * 填充时间时分秒<br/>
	 *
	 * @param dateStr
	 *            yyyy-MM-dd HH:mm:ss字符串
	 * @return net.maxt.util.Date 日期 ,转换异常时返回null。
	 */
	public static Date parseDateAppendSeconds(String dateStr) {
		SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm");
		try {
			java.util.Date d = sdf.parse(dateStr);
			return new Date(d.getTime());
		} catch (ParseException e) {
			e.printStackTrace();
			return null;
		}
	}

	/**
	 * 填充时间时分秒<br/>
	 *
	 * @param dateStr
	 *            yyyy-MM-dd HH:mm:ss字符串
	 * @return net.maxt.util.Date 日期 ,转换异常时返回null。
	 */
	public static Date parseDateAppend(String dateStr) {
		SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
		try {
			java.util.Date d = sdf.parse(dateStr + " 00:00:00");
			return new Date(d.getTime());
		} catch (ParseException e) {
			e.printStackTrace();
			return null;
		}
	}

	/**
	 * 将yyyy-MM-dd HH:mm:ss字符串转换成日期(net.maxt.util.Date)<br/>
	 *
	 * @param dateStr
	 *            yyyy-MM-dd HH:mm:ss字符串
	 * @return net.maxt.util.Date 日期 ,转换异常时返回null。
	 */
	public static String getNowDateToString() {
		SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
		return sdf.format(new Date());
	}

	/**
	 * 将yyyy-MM-dd HH:mm:ss字符串转换成日期(java.util.Date)<br/>
	 *
	 * @param dateStr
	 *            yyyy-MM-dd HH:mm:ss字符串
	 * @return net.maxt.util.Date 日期 ,转换异常时返回null。
	 */
	public static Date parseDate(String dateStr) {
		SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
		try {
			java.util.Date d = sdf.parse(dateStr);
			return new Date(d.getTime());
		} catch (ParseException e) {
			e.printStackTrace();
			return null;
		}
	}

	public static Date parseYearDay(String dateStr) {
		SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM");
		try {
			java.util.Date d = sdf.parse(dateStr);
			return new Date(d.getTime());
		} catch (ParseException e) {
			e.printStackTrace();
			return null;
		}
	}

	public static Date parseDate2(String dateStr) {
		SimpleDateFormat sdf = new SimpleDateFormat("yyyy/MM/dd HH:mm:ss");
		try {
			java.util.Date d = sdf.parse(dateStr);
			return new Date(d.getTime());
		} catch (ParseException e) {
			e.printStackTrace();
			return null;
		}
	}

	/**
	 * 将yyyy-MM-dd 字符串转换成日期(net.maxt.util.Date)<br/>
	 *
	 * @param dateStr
	 *            yyyy-MM-dd 字符串
	 * @return net.maxt.util.Date 日期 ,转换异常时返回null。
	 */
	public static Date parseDateShortDate(Date date) {
		SimpleDateFormat sdf = new SimpleDateFormat(DEFAULT_FORMAT);
		try {
			java.util.Date d = sdf.parse(sdf.format(date));
			return new Date(d.getTime());
		} catch (ParseException e) {
			e.printStackTrace();
			return null;
		}
	}

	/**
	 * 将yyyy-MM-dd 字符串转换成日期(net.maxt.util.Date)<br/>
	 *
	 * @param dateStr
	 *            yyyy-MM-dd 字符串
	 * @return net.maxt.util.Date 日期 ,转换异常时返回null。
	 */
	public static Date parseDateShort(String dateStr) {
		SimpleDateFormat sdf = new SimpleDateFormat(DEFAULT_FORMAT);
		try {
			java.util.Date d = sdf.parse(dateStr);
			return new Date(d.getTime());
		} catch (ParseException e) {
			e.printStackTrace();
			return null;
		}
	}

	/**
	 * 从excel导入 时间格式 02-八月-2016
	 *
	 * @param dateStr
	 * @return
	 */
	public static Date parseDateExcel(String dateStr) {
		SimpleDateFormat sdf = new SimpleDateFormat(DEFAULT_FORMAT);
		try {
			java.util.Date d = sdf.parse(dateStr);
			return new Date(d.getTime());
		} catch (ParseException e) {
			e.printStackTrace();
			return null;
		}
	}

	/**
	 * 将yyyy-MM-dd HH:mm to yyyy-MM-dd HH:mm:ss
	 *
	 * @param dateStr
	 *            yyyy-MM-dd HH:mm:ss字符串
	 * @return net.maxt.util.Date 日期 ,转换异常时返回null。
	 */
	public static String parseDatetoShortHHmm(Date date) {
		SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm");
		return sdf.format(date);
	}

	/**
	 * 将yyyy-MM-dd HH:mm:ss字符串转换成日期(net.maxt.util.Date)<br/>
	 *
	 * @param dateStr
	 *            yyyy-MM-dd HH:mm:ss字符串
	 * @return net.maxt.util.Date 日期 ,转换异常时返回null。
	 */
	public static String parseDatetoShort(Date date) {
		SimpleDateFormat sdf = new SimpleDateFormat(DEFAULT_FORMAT);
		return sdf.format(date);
	}

	public static String parseTimeStamp(Date date) {
		DateFormat df = new SimpleDateFormat("yyyyMMddHHmmss");
		return df.format(date);
	}

	/**
	 * 将yyyy-MM-dd HH:mm:ss字符串转换成日期(net.maxt.util.Date)<br/>
	 *
	 * @param dateStr
	 *            yyyy-MM-dd HH:mm:ss字符串
	 * @return net.maxt.util.Date 日期 ,转换异常时返回null。
	 */
	public static String parsetoShort(Date date) {
		SimpleDateFormat sdf = new SimpleDateFormat(DEFAULT_FORMAT);
		return sdf.format(date);
	}

	/**
	 * 功能：当前时间增加毫秒数。
	 *
	 *
	 * @param milliseconds
	 *            正值时时间延后，负值时时间提前。
	 * @return Date
	 */
	public static Date addMilliseconds(int milliseconds, Date date) {
		Calendar c = Calendar.getInstance();
		c.setTime(date);
		c.set(Calendar.MILLISECOND, c.get(Calendar.MILLISECOND) + milliseconds);
		return new Date(c.getTimeInMillis());
	}

	/**
	 * 功能：当前时间增加秒数。
	 *
	 *
	 * @param seconds
	 *            正值时时间延后，负值时时间提前。
	 * @return Date
	 */
	public static Date addSeconds(int seconds, Date date) {
		Calendar c = Calendar.getInstance();
		c.setTime(date);
		c.set(Calendar.SECOND, c.get(Calendar.SECOND) + seconds);
		return new Date(c.getTimeInMillis());
	}

	public static Date subtractSeconds(int seconds, Date date) {
		Calendar c = Calendar.getInstance();
		c.setTime(date);
		c.set(Calendar.SECOND, c.get(Calendar.SECOND) - seconds);
		return new Date(c.getTimeInMillis());
	}

	/**
	 * 功能：当前时间增加分钟数。
	 *
	 *
	 * @param minutes
	 *            正值时时间延后，负值时时间提前。
	 * @return Date
	 */
	public static Date addMinutes(int minutes, Date date) {
		Calendar c = Calendar.getInstance();
		c.setTime(date);
		c.set(Calendar.MINUTE, c.get(Calendar.MINUTE) + minutes);
		return new Date(c.getTimeInMillis());
	}

	public static Date subtractionMinutes(int minutes, Date date) {
		Calendar c = Calendar.getInstance();
		c.setTime(date);
		c.set(Calendar.MINUTE, c.get(Calendar.MINUTE) - minutes);
		return new Date(c.getTimeInMillis());
	}


	/**
	 * 功能：当前时间增加小时数。
	 *
	 *
	 * @param hours
	 *            正值时时间延后，负值时时间提前。
	 * @return Date
	 */
	public static Date addHours(int hours, Date date) {
		Calendar c = Calendar.getInstance();
		c.setTime(date);
		c.set(Calendar.HOUR, c.get(Calendar.HOUR) + hours);
		return new Date(c.getTimeInMillis());
	}

	/**
	 * 功能：当前时间增加天数。
	 *
	 *
	 * @param days
	 *            正值时时间延后，负值时时间提前。
	 * @return Date
	 */
	public static Date addDays(int days, Date date) {
		Calendar c = Calendar.getInstance();
		c.setTime(date);
		c.set(Calendar.DATE, c.get(Calendar.DATE) + days);
		return new Date(c.getTimeInMillis());
	}

	/**
	 * 功能：当前时间增加月数。
	 *
	 * @param months
	 *            正值时时间延后，负值时时间提前。
	 * @return Date
	 */
	public static Date addMonths(int months, Date date) {
		Calendar c = Calendar.getInstance();
		c.setTime(date);
		c.set(Calendar.MONTH, c.get(Calendar.MONTH) + months);
		return new Date(c.getTimeInMillis());
	}

	/**
	 * 功能：当前时间增加年数。注意遇到2月29日情况，系统会自动延后或者减少一天。
	 *
	 * @param years
	 *            正值时时间延后，负值时时间提前。
	 * @return Date
	 */
	public static Date addYears(int years, Date date) {
		Calendar c = Calendar.getInstance();
		c.setTime(date);
		c.set(Calendar.YEAR, c.get(Calendar.YEAR) + years);
		return new Date(c.getTimeInMillis());
	}

	/**
	 * 返回当月的第一天
	 *
	 * @param date
	 * @return
	 */
	public static String returnMonthOneDay(String date) {
		Date d = null;
		try {
			d = new SimpleDateFormat(DEFAULT_FORMAT).parse(date + "-01");
		} catch (ParseException e) {
			e.printStackTrace();
		}
		return DateUtils.parseDatetoShort(d);
	}

	/**
	 * 返回当月的最后一天
	 *
	 * @param date
	 * @return
	 */
	public static String returnMonthLastDay(String date) {
		Date d = null;
		try {
			d = new SimpleDateFormat(DEFAULT_FORMAT).parse(returnMonthOneDay(date));
			Calendar cDay = Calendar.getInstance();
			cDay.setTime(d);
			int day = cDay.getActualMaximum(Calendar.DAY_OF_MONTH);
			int year = cDay.get(Calendar.YEAR);
			int month = cDay.get(Calendar.MONTH) + 1;
			return year + "-" + month + "-" + day;
		} catch (ParseException e) {
			e.printStackTrace();
		}
		return DateUtils.parseDatetoShort(new Date());
	}

	public static String toShortDateYYYYMonth(Date createtime) {
		SimpleDateFormat sdf = new SimpleDateFormat("yyyyMM");
		return sdf.format(createtime);
	}

    /**
	 * 得到秒。格式：56<br/>
	 *
	 * @return int
	 */
	public int secondInt() {
		return Integer.parseInt(toString("ss"));
	}

	/**
	 * 得到分钟。格式：56<br/>
	 *
	 * @return int
	 */
	public int minuteInt() {
		return Integer.parseInt(toString("mm"));
	}

	/**
	 * 得到小时。格式：23<br/>
	 *
	 * @return int
	 */
	public int hourInt() {
		return Integer.parseInt(toString("HH"));
	}

	/**
	 * 得到日。格式：26<br/>
	 * 注意：这里1日返回1,2日返回2。
	 *
	 * @return int
	 */
	public int dayInt() {
		return Integer.parseInt(toString("dd"));
	}

	/**
	 * 得到月。格式：5<br/>
	 * 注意：这里1月返回1,2月返回2。
	 *
	 * @return int
	 */
	public int monthInt() {
		return Integer.parseInt(toString("MM"));
	}

	/**
	 * 得到年。格式：2013
	 *
	 * @return int
	 */
	public int yearInt() {
		return Integer.parseInt(toString("yyyy"));
	}

	/**
	 * 得到短时间。格式：12:01
	 *
	 * @return String
	 */
	public String shortTime() {
		return toString("HH:mm");
	}

	/**
	 * 得到长时间。格式：12:01:01
	 *
	 * @return String
	 */
	public String longTime() {
		return toString("HH:mm:ss");
	}

	/**
	 * 得到今天的第一秒的时间。
	 *
	 * @return Date
	 */
	public Date dayStart() {
		Calendar c = Calendar.getInstance();
		c.setTime(this);
		c.set(Calendar.HOUR_OF_DAY, 0);
		c.set(Calendar.MINUTE, 0);
		c.set(Calendar.SECOND, 0);
		return new Date(c.getTimeInMillis());
	}

	/**
	 * 得到当前所在自然月的第一天的开始,格式为长日期格式。例如：2012-03-01 00:00:00。
	 *
	 * @return Date
	 */
	public Date monthStart() {
		Calendar c = Calendar.getInstance();
		String startStr = toString("yyyy-M-") + c.getActualMinimum(Calendar.DATE) + " 00:00:00";
		return DateUtils.parseDate(startStr);
	}

	/**
	 * 得到今天的最后一秒的时间。
	 *
	 * @return Date
	 */
	public Date dayEnd() {
		Calendar c = Calendar.getInstance();
		c.setTime(this);
		c.set(Calendar.HOUR_OF_DAY, 23);
		c.set(Calendar.MINUTE, 59);
		c.set(Calendar.SECOND, 59);
		return new Date(c.getTimeInMillis());
	}

	/**
	 * 根据日期得到星期几,得到数字。<br/>
	 * 7, 1, 2, 3, 4, 5, 6
	 *
	 * @return Integer 如：6
	 */
	public static int dayOfWeekNumber(Date date) {
		Integer dayNames[] = { 7, 1, 2, 3, 4, 5, 6 };
		// String dayNamesString[] = { "周日", "周一", "周二", "周三", "周四", "周五", "周六"
		// };
		Calendar calendar = Calendar.getInstance();
		calendar.setTime(date);
		int dayOfWeek = calendar.get(Calendar.DAY_OF_WEEK) - 1;
		if (dayOfWeek < 0)
			dayOfWeek = 0;
		return dayNames[dayOfWeek];
		// return dayNames[dayOfWeek];
	}

	/**
	 * 根据日期得到星期几,得到数字。<br/>
	 * 7, 1, 2, 3, 4, 5, 6
	 *
	 * @return Integer 如：6
	 */
	public static String dayOfWeekString(Date date) {
		// Integer dayNames[] = { 7, 1, 2, 3, 4, 5, 6 };
		String dayNamesString[] = { "周日", "周一", "周二", "周三", "周四", "周五", "周六" };
		Calendar calendar = Calendar.getInstance();
		calendar.setTime(date);
		int dayOfWeek = calendar.get(Calendar.DAY_OF_WEEK) - 1;
		if (dayOfWeek < 0)
			dayOfWeek = 0;
		return dayNamesString[dayOfWeek];
		// return dayNames[dayOfWeek];
	}

	/**
	 * 将日期转换成长日期字符串 例如：2009-09-09 01:01:01
	 *
	 * @return String
	 */
	public static String toLongDateCh(Date date) {
		DateFormat df = new SimpleDateFormat("yyyy年MM月dd日 HH:mm:ss");
		return (null == date) ? null : df.format(date);
	}

	/**
	 * 将日期转换成长日期字符串 例如：2009-09-09 01:01:01
	 *
	 * @return String
	 */
	public static String toLongDate(Date date) {
		DateFormat df = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
		return (null == date) ? null : df.format(date);
	}

	public static String toLongDateExcel(Date date) {
		DateFormat df = new SimpleDateFormat("yyyy/M/d H:m");
		return (null == date) ? null : df.format(date);
	}
	/**
	 * 将日期转换成长日期字符串 例如
	 *
	 * @return String
	 */
	public static String parseDateMonthToHours(Date date) {
		DateFormat df = new SimpleDateFormat("MM-dd HH:mm");
		return (null == date) ? null : df.format(date);
	}

	/**
	 * 将日期按照一定的格式进行格式化为字符串。<br/>
	 * 例如想将时间格式化为2012-03-05 12:56 ,则只需要传入formate为yyyy-MM-dd HH:mm即可。
	 *
	 * @param formate
	 *            格式化格式，如：yyyy-MM-dd HH:mm
	 * @return String 格式后的日期字符串。如果当前对象为null，则直接返回null。
	 */
	public String toString(String formate) {
		DateFormat df = new SimpleDateFormat(formate);
		return (null == this) ? null : df.format(this);
	}


	/**
	 * 检查传入时间是否比当前时间大于指定毫秒数
	 * @param orders
	 */
	public static boolean checkOrderTime(Date orderTime,int second){
		Calendar calendar = Calendar.getInstance();
		calendar.setTime(orderTime);
		calendar.set(Calendar.SECOND, second);
		//如果当前时间大于 二维码生成时间加配置分钟数 则订单失败 否则加入队列 默认 一分半 90 秒
		return compareDate(getNowDate(), calendar.getTime());
	}

	/**
	 * 得到某个时间的时间戳yyyyMMddHHmmss。
	 *
	 * @param date
	 *            时间
	 * @return String 如果当前对象为null，则直接返回null。
	 */
	public String toTimeStamp() {
		DateFormat df = new SimpleDateFormat("yyyyMMddHHmmss");
		return (null == this) ? null : df.format(this);
	}

	public String toTimeStamps() {
		DateFormat df = new SimpleDateFormat("yyyyMMddHHmmssSSS");
		return (null == this) ? null : df.format(this);
	}

	public String toTimeStampMonthDay() {
		DateFormat df = new SimpleDateFormat("yyyyMMdd");
		return (null == this) ? null : df.format(this);
	}

	public String toTimeStampMonthDay(Date date) {
		DateFormat df = new SimpleDateFormat("yyyyMMdd");
		return (null == this) ? null : df.format(date);
	}

	/**
	 * 将日期转换成短日期字符串,例如：2009-09-09。
	 *
	 * @return String ,如果当前对象为null，返回null。
	 */
	public static String toShortDate(Date date) {
		DateFormat df = new SimpleDateFormat(DEFAULT_FORMAT);
		return (null == date) ? null : df.format(date);
	}

	/**
	 * 将日期转换成短日期字符串,例如：2009-09-09。
	 *
	 * @return String ,如果当前对象为null，返回null。
	 */
	public static String parseDateToHoursSecond(Date date) {
		DateFormat df = new SimpleDateFormat("HH:mm:ss");
		return (null == date) ? null : df.format(date);
	}

	/**
	 * 获得周一的日期
	 *
	 * @param date
	 * @return
	 */
	public static String getMonday(Date date) {
		// Calendar calendar = Calendar.getInstance();
		//// calendar.setTime(date);
		// calendar.set(Calendar.DAY_OF_WEEK, Calendar.MONDAY);
		// calendar.set(Calendar.HOUR_OF_DAY, 0);
		// calendar.set(Calendar.MINUTE, 0);
		// calendar.set(Calendar.SECOND, 0);
		// return toLongDate(calendar.getTime());
		Calendar calendar = Calendar.getInstance();
		calendar.setFirstDayOfWeek(Calendar.SUNDAY);
		calendar.setTime(date);
		calendar.set(Calendar.HOUR_OF_DAY, 0);
		calendar.set(Calendar.MINUTE, 0);
		calendar.set(Calendar.SECOND, 0);
		calendar.set(Calendar.DAY_OF_WEEK, calendar.getFirstDayOfWeek()+1);
		return toLongDate(calendar.getTime());

	}

	/**
	 * 获得周日的日期
	 *
	 * @param date
	 * @return
	 */
	public static String getSunday(Date date) {
		// Calendar calendar = Calendar.getInstance();
		// calendar.setTime(date);
		// calendar.set(Calendar.DAY_OF_WEEK, Calendar.SUNDAY);
		// return toLongDate(calendar.getTime());
		Calendar calendar = Calendar.getInstance();
		calendar.setFirstDayOfWeek(Calendar.SUNDAY);
		calendar.setTime(date);
		calendar.set(Calendar.HOUR_OF_DAY, 47);
		calendar.set(Calendar.MINUTE, 59);
		calendar.set(Calendar.SECOND, 59);
		calendar.set(Calendar.DAY_OF_WEEK, calendar.getFirstDayOfWeek() + 6);
		return toLongDate(calendar.getTime());
	}

	/**
	 * 格式化日期
	 *
	 * @param date
	 *            日期对象
	 * @return String 日期字符串
	 */
	public static String formatDate(Date date) {
		SimpleDateFormat f = new SimpleDateFormat(DEFAULT_FORMAT);
		String sDate = f.format(date);
		return sDate;
	}

	/**
	 * 获取当年的第一天
	 *
	 * @param year
	 * @return
	 */
	public static Date getCurrYearFirst() {
		Calendar currCal = Calendar.getInstance();
		int currentYear = currCal.get(Calendar.YEAR);
		return getYearFirst(currentYear);
	}

	/**
	 * 获取当年的最后一天
	 *
	 * @param year
	 * @return
	 */
	public static Date getCurrYearLast() {
		Calendar currCal = Calendar.getInstance();
		int currentYear = currCal.get(Calendar.YEAR);
		return getYearLast(currentYear);
	}

	/**
	 * 获取某年第一天日期
	 *
	 * @param year
	 *            年份
	 * @return Date
	 */
	public static Date getYearFirst(int year) {
		Calendar calendar = Calendar.getInstance();
		calendar.clear();
		calendar.set(Calendar.YEAR, year);
		Date currYearFirst = calendar.getTime();
		return currYearFirst;
	}

	/**
	 * 获取某年最后一天日期
	 *
	 * @param year
	 *            年份
	 * @return Date
	 */
	public static Date getYearLast(int year) {
		Calendar calendar = Calendar.getInstance();
		calendar.clear();
		calendar.set(Calendar.YEAR, year);
		calendar.roll(Calendar.DAY_OF_YEAR, -1);
		Date currYearLast = calendar.getTime();

		return currYearLast;
	}

	/**
	 * 时间比较
	 *
	 * @param date1
	 * @param date2
	 * @return true or false
	 */
	public static boolean compareDate(Date date1, Date date2) {
		if (date1 != null && date2 != null) {
			return date1.getTime() > date2.getTime();
		}
		return false;
	}
	public static Date setMinute(Date time,int minute){
		Calendar ca = Calendar.getInstance();
		ca.setTime(time);
		ca.add(Calendar.MINUTE, minute);
		return ca.getTime();
	}

	/**
	 * 功能：用java.util.Date进行构造。
	 *
	 * @param java.util.Date
	 *            date
	 */
	public DateUtils(java.util.Date date) {
		super(date.getTime());
	}

	/**
	 * 功能：用毫秒进行构造。
	 *
	 * @param timeInMillis
	 */
	public DateUtils(long timeInMillis) {
		super(timeInMillis);
	}

	/**
	 * 功能：默认构造函数。
	 *
	 */
	public DateUtils() {
		super();
	}

	public static void main(String[] args) {
//		System.out.println(getMonthOfYear(getNowDate()));
		System.out.println(DateUtils.parse("20180916224309","yyyyMMddHHmmss").getTime());
//		System.out.println(getSunday(DateUtils.getNowDate()));
	}

}
